.TH std::fill 3 "2024.06.10" "http://cppreference.com" "C++ Standard Libary"
.SH NAME
std::fill \- std::fill

.SH Synopsis
   Defined in header <algorithm>
   template< class ForwardIt, class T >                  (constexpr since
   void fill( ForwardIt first, ForwardIt last,           C++20)
   const T& value );                                     (until C++26)
   template< class ForwardIt, class T = typename
   std::iterator_traits


    <ForwardIt>::value_type >                            (since C++26)
   constexpr void fill( ForwardIt first,
   ForwardIt last,

                        const T& value );
   template< class ExecutionPolicy, class
   ForwardIt, class T >
                                                 \fB(1)\fP                      \fI(since C++17)\fP
   void fill( ExecutionPolicy&& policy,                                   (until C++26)

              ForwardIt first, ForwardIt last,
   const T& value );
   template< class ExecutionPolicy,
                                                     \fB(2)\fP
             class ForwardIt, class T = typename
   std::iterator_traits
                                                                          (since C++26)
    <ForwardIt>::value_type >
   void fill( ExecutionPolicy&& policy,

              ForwardIt first, ForwardIt last,
   const T& value );

   1) Assigns the given value to all elements in the range [first, last).
   2) Same as \fB(1)\fP, but executed according to policy.
   This overload participates in overload resolution only if

   std::is_execution_policy_v<std::decay_t<ExecutionPolicy>> is true.        (until
                                                                             C++20)
   std::is_execution_policy_v<std::remove_cvref_t<ExecutionPolicy>> is true. (since
                                                                             C++20)

   If value is not writable to first, the program is ill-formed.

.SH Parameters

   first, last - the range of elements to modify
   value       - the value to be assigned
   policy      - the execution policy to use. See execution policy for details.
.SH Type requirements
   -
   ForwardIt must meet the requirements of LegacyForwardIterator.

.SH Complexity

   Exactly std::distance(first, last) assignments.

.SH Exceptions

   The overload with a template parameter named ExecutionPolicy reports errors as
   follows:

     * If execution of a function invoked as part of the algorithm throws an exception
       and ExecutionPolicy is one of the standard policies, std::terminate is called.
       For any other ExecutionPolicy, the behavior is implementation-defined.
     * If the algorithm fails to allocate memory, std::bad_alloc is thrown.

.SH Possible implementation

                                     fill
   template<class ForwardIt,
            class T = typename std::iterator_traits<ForwardIt>::value_type>
   void fill(ForwardIt first, ForwardIt last, const T& value)
   {
       for (; first != last; ++first)
           *first = value;
   }

.SH Notes

             Feature-test macro           Value    Std              Feature
   __cpp_lib_algorithm_default_value_type 202403 (C++26) List-initialization for
                                                         algorithms (1,2)

.SH Example


// Run this code

 #include <algorithm>
 #include <complex>
 #include <iostream>
 #include <vector>

 void println(const auto& seq)
 {
     for (const auto& e : seq)
         std::cout << e << ' ';
     std::cout << '\\n';
 }

 int main()
 {
     std::vector<int> v{0, 1, 2, 3, 4, 5, 6, 7, 8};
     println(v);

     // set all of the elements to 8
     std::fill(v.begin(), v.end(), 8);
     println(v);

     std::vector<std::complex<double>> nums{{1, 3}, {2, 2}, {4, 8}};
     println(nums);
     #ifdef __cpp_lib_algorithm_default_value_type
         std::fill(nums.begin(), nums.end(), {4, 2});
     #else
         std::fill(nums.begin(), nums.end(), std::complex<double>{4, 2});
     #endif
     println(nums);
 }

.SH Output:

 0 1 2 3 4 5 6 7 8
 8 8 8 8 8 8 8 8 8
 (1,3) (2,2) (4,8)
 (4,2) (4,2) (4,2)

   Defect reports

   The following behavior-changing defect reports were applied retroactively to
   previously published C++ standards.

     DR    Applied to         Behavior as published               Correct behavior
                      T was required to be CopyAssignable,   required to be writable
   LWG 283 C++98      but                                    instead
                      T is not always writable to ForwardIt

.SH See also

   fill_n       copy-assigns the given value to N elements in a range
                \fI(function template)\fP
   copy         copies a range of elements to a new location
   copy_if      \fI(function template)\fP
   \fI(C++11)\fP
                assigns the results of successive function calls to every element in a
   generate     range
                \fI(function template)\fP
                applies a function to a range of elements, storing results in a
   transform    destination range
                \fI(function template)\fP
   ranges::fill assigns a range of elements a certain value
   (C++20)      (niebloid)
